﻿#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <pthread.h>

#include "task.h"
#include "atomic_int.h"
#include "thread_factory.h"

#include <map>
#include <queue>
#include <vector>
#include <thread>
#include <iostream>

using namespace std;

#define TASK_QUEUE_CAPACITY 15

enum Time_Unit {
    Second,         // 秒
    Millisecond,    // 毫秒
    Microsecond,    // 微秒
    Nanosecond,     // 纳秒
};

enum Thread_Pool_State {
    Running,            // 运行态: 线程池的默认状态, 运行态能够接受新添加任务, 也能够对阻塞队列中的任务进行处理;
    Shutdown,           // 关闭态: 能够对阻塞队列中的任务进行处理, 不能够接受新添加的任务;
    Terminated,         // 结束态: 此状态也表示整个线程池生命周期的结束;
};

enum RejectionPolicy {
    AbortPolicy,            // 抛出异常
    CallerRunsPolicy,       // 由调用者执行任务
    BlockingWaitPolicy,     // 阻塞等待任务的提交
    DiscardPolicy,          // 丢弃任务
    DiscardOldestPolicy,    // 丢弃最早排队任务
};

class ThreadPool {
private:
public:
    ThreadPool(int keep_alive_time, int core_thread_number, int maximum_thread_number, queue<Task> *task_queue,
               ThreadFactory *factory);

    ThreadPool(int keep_alive_time, int core_thread_number, int maximum_thread_number, queue<Task> *task_queue,
               ThreadFactory *factory, Time_Unit time_unit, RejectionPolicy policy);

    virtual ~ThreadPool();

    ThreadPool(const ThreadPool &) = default;

public:
    int server_fd = -1;                         // 服务器文件描述符

private:
    Thread_Pool_State state = Running;          // 线程池状态

    Time_Unit time_unit = Second;               // 时间单位

    int keep_alive_time;                        // 线程存活时间(默认秒)

    int core_thread_number;                     // 核心线程数

    int maximum_thread_number;                  // 最大线程数

    queue<Task> *task_queue;                    // 任务队列;

    ThreadFactory *factory;                     // 线程工厂

    RejectionPolicy policy = DiscardPolicy;     // 拒绝策略

    pthread_t manager_thread_pid;                       // 管理者线程PID
    vector<pthread_t> work_thread_pid_list;             // 工作线程PID列表
    map<pthread_t, long> work_thread_alive_time_map;    // 工作线程PID存活的时间映射

    AtomicInt work_thread_number;                   // 工作线程数
    AtomicInt alive_thread_number;                  // 存活线程数

    pthread_mutex_t task_queue_mutex;               // 任务队列互斥锁
    pthread_mutex_t thread_pool_mutex;              // 线程池互斥锁
    pthread_cond_t task_queue_is_fill_cond;         // 任务队列为满时的条件变量
    pthread_cond_t task_queue_is_empty_cond;        // 任务队列为空时的条件变量

private:
    int getNewWorkThreadIndex();

    // 工作线程的工作函数
    static void *workThreadWorkFunction(void *args);

    // 管理者线程的工作函数
    static void *managerThreadWorkFunction(void *args);

    // 工作线程退出函数
    static void workThreadExitFunction(void *args);

public:
    // 关闭线程池
    void shutdown();

    // 向线程池提交任务
    bool submitTask(void *args, callback function);

    // 向线程池提交任务
    bool submitTask(Task task);

    // 获取线程池存活线程的数量
    int getAliveThreadNumber();

    // 获取线程池工作线程的数量
    int getWorkThreadNumber();
};
